package main

import (
	"fmt"
	"sort"
)

// ---------- 1. 内置快捷排序 ----------
func builtinSort() {
	strs := []string{"banana", "apple", "pear"}
	sort.Strings(strs)
	fmt.Println("Strings:", strs)

	ints := []int{42, 3, 7, 1}
	sort.Ints(ints)
	fmt.Println("Ints   :", ints)

	floats := []float64{3.14, 2.71, 1.41}
	sort.Float64s(floats)
	fmt.Println("Float64:", floats)
}

// ---------- 2. 自定义结构体 + 实现 sort.Interface ----------
type Person struct {
	Name string
	Age  int
}

type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

type ByAgeDesc []Person

func (a ByAgeDesc) Len() int           { return len(a) }
func (a ByAgeDesc) Less(i, j int) bool { return a[i].Age > a[j].Age }
func (a ByAgeDesc) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

// ---------- 3. sort.Slice 演示 ----------
func sliceSort() {
	people := []Person{
		{"Alice", 30},
		{"Bob", 25},
		{"Carol", 35},
	}

	// 升序
	sort.Slice(people, func(i, j int) bool {
		return people[i].Age < people[j].Age
	})
	fmt.Println("Slice asc :", people)

	// 降序
	sort.Slice(people, func(i, j int) bool {
		return people[i].Age > people[j].Age
	})
	fmt.Println("Slice desc:", people)
}

func main() {
	builtinSort()
	fmt.Println("------ sort.Interface ------")
	people := []Person{
		{"Alice", 30},
		{"Bob", 25},
		{"Carol", 35},
	}
	sort.Sort(ByAge(people))
	fmt.Println("Interface asc :", people)
	sort.Sort(ByAgeDesc(people))
	fmt.Println("Interface desc:", people)

	fmt.Println("------ sort.Slice ----------")
	sliceSort()
}

// 字符串（String）	StringSlice	sort.Strings(a [] string)	字符 ASCII 值升序
// 整型（int）	IntSlice	sort.Ints(a []int)	数值升序
// 双精度浮点（float64）	Float64Slice	sort.Float64s(a []float64)	数值升序
// sort.Slice 需要传入方法签，适合临时排序需求，
// sort.Interface 需要实现接口，适合多次复用排序逻辑
// 两者都使用了**快速排序（Quicksort）**算法，平均时间复杂度 O(n log n)
// Go 标准库的排序是稳定排序（Stable Sort），相等元素的相对顺序不会改变